﻿using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Xml.Linq;
using System.Collections.Generic;
public partial class _35newpart_Linq_First_FirstOrDefault_Last_LastOrDefault_ElementAt_ElementAtOrDefault_Contains_Any_All_Count_LongCount_Sum_Min_Max_Average_Aggregate_Cast_DefaultIfEmpty_SequenceEqual_OfType_ToArray : System.Web.UI.Page
{
    public Linq查询DataContext LDb = new Linq查询DataContext();
    /*
       ·First - 返回集合中的第一个元素；不延迟
    ·FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟
    ·Last - 返回集合中的最后一个元素；不延迟
    ·LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）
    ·ElementAt - 返回集合中指定索引的元素；不延迟
    ·ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟
    ·Contains - 判断集合中是否包含有某一元素；不延迟
    ·Any - 判断集合中是否有元素满足某一条件；不延迟
    ·All - 判断集合中是否所有元素都满足某一条件；不延迟
    ·Count - 返回集合中的元素个数，返回int；不延迟
    ·LongCount - 返回集合中的元素个数，返回long；不延迟
    ·Sum - 集合应为数字类型集合，求其和；不延迟
    ·Min - 返回集合的最小值；不延迟
    ·Max - 返回集合的最大值；不延迟
    ·Average - 集合应为数字类型集合，求其平均值；不延迟
    ·Aggregate - 根据输入的表达式获取一个聚合值；不延迟
    ·Cast - 将集合转换为强类型集合；延迟
    ·DefaultIfEmpty - 查询结果为空则返回默认值；延迟
    ·SequenceEqual - 判断两个集合是否相同；不延迟
    ·OfType - 过滤集合中的指定类型；延迟
    ·ToArray - 将集合转换为数组；不延迟
    ·ToList - 将集合转换为List<T>集合；不延迟
    ·ToDictionary - 将集合转换为<K, V>集合；不延迟
     */
    protected void Page_Load(object sender, EventArgs e)
    {
        ///返回集合中的第一个元素；不延迟
        _Summary_First();

        ///FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟
        _Summary_FirstOrDefault();

        ///LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）
       // _Summary_Last_LastOrDefault(); //看来不支持

        ///ElementAt - 返回集合中指定索引的元素；不延迟
        _Summary_ElementAt_ElementOrDefault();

        ///判断集合中是否包含有某一元素；不延迟
        _Summary_Contains();

        ///判断集合中是否所有元素都满足某一条件；不延迟
        _Summary_All();

        ///判断集合中是否所有元素都满足某一条件；不延迟
        _Summary_Any();

        //_Summary_Count_LongConut
        _Summary_Count_LongConut();

        //集合应为数字类型集合，求其和；不延迟
        _Summary_Sum();

        ///返回集合的最小值；不延迟
        _Summary_Min();

        /// 集合应为数字类型集合，求其平均值；不延迟
        _Summary_Average();


        ///据输入的表达式获取一个聚合值；不延迟
        ///_Summary_Aggregate();

        /// 将集合转换为强类型集合；延迟
        _Summary_Cast();

        //查询结束为空返回默认值
        _Summary_DefaultIfEmpty();

        ///看看两个值是不是相等
        //不支持_Summary_SequenceEqual();

        ///过滤集合中的指定类型；延迟
        _Summary_OfType();

        ///把集合转成数组
        _Summary_ToArray();

        ///ToList - 将集合转换为List<T>集合；不延迟
        _Summary_ToLsit();

        ///将集合转换为<K, V>集合；不延迟
        _Summary_ToDictionary();
    }



    #region  LINQ查询操作符之First、FirstOrDefault、Last、LastOrDefault、ElementAt、ElementAtOrDefault、Contains、Any、All、Count、LongCount、Sum、Min、Max、Average、Aggregate、Cast、DefaultIfEmpty、SequenceEqual、OfType、ToArray、ToList、ToDictionary
    /// <summary>
    ///First -  返回集合中的第一个元素；不延迟
    /// </summary>
    void _Summary_First()
    { 
        Response.Write(LDb.books.First().bookname+"<br/>");
        ///在frist中可以使用表达式)        
        // string s = (from a in _ary
        //             select a).FirstOrDefault(a => a.StartsWith("xxx"));
        // s == null
    }

    /// <summary>
    /// FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟
    /// </summary>
    void _Summary_FirstOrDefault()
    {
        Response.Write(LDb.books.Where(p=>p.bookname.Contains("金")).FirstOrDefault().bookname);//这里使用了like 操作，看来select 不能用like操作
    }

    /*
    Last - 返回集合中的最后一个元素；不延迟
    LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）
     */

    /// <summary>
    ///Last - 返回集合中的最后一个元素；不延迟
    /// LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）
    /// </summary>
    void _Summary_Last_LastOrDefault()
    {
        var product = (from p in LDb.books
                       select p);//.Last(p=>p.bookname.StartsWith("金"));
        Response.Write("<br/> Last - 返回集合中的最后一个元素；不延迟"+product.Last().bookname+"<br/>");
    
        
    }
    /// <summary>
    ///ElementAt - 返回集合中指定索引的元素；不延迟
    ///ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟
    /// </summary>
    void _Summary_ElementAt_ElementOrDefault()
    {
        //不支持
        //var  s = (from p in LDb.books
        //            select p).ElementAt(3);//返回指定的原素
        // string s = (from a in _ary
        //             select a).ElementAtOrDefault(1000);
        // s == null

       // Response.Write("<br/>"+s.bookname);
        
    }
    
    /// <summary>
    /// Contains - 判断集合中是否包含有某一元素；不延迟
    /// </summary>
    void _Summary_Contains()
    {
        //运行结果
        //True
        Response.Write(LDb.books.Where(p => p.bookname.Contains("数据")).FirstOrDefault().bookname);
    }

    //All - 判断集合中是否所有元素都满足某一条件；不延迟
   
    /// <summary>
    ///  判断集合中是否所有元素都满足某一条件；不延迟
    /// </summary>
    void _Summary_All()
    {

        bool products = (from p in LDb.books
                         select p).All(p => p.bookname.Length > 10);
        Response.Write("<br/>"+products);
      }

    /// <summary>
    /// 判断集合中是否有元素满足某一条件；不延迟
    /// </summary>
    void _Summary_Any()
    { 
        bool products  = (from p in LDb.books
                          select p)
                          .Any(p=>p.bookname.Contains("0"));//返回ture

        Response.Write("<br/>判断集合中是否有元素满足某一条件；不延迟::"+products);
    }

    /// <summary>
    /// Count - 返回集合中的元素个数，返回int；不延迟
    ///LongCount - 返回集合中的元素个数，返回long；不延迟
    /// </summary>
    void _Summary_Count_LongConut()
    {
        int i = (from p in LDb.books
                 select p).Count(p => p.bookname.Length > 30);

        //long j = LDb.books.LongCount(p => p.bookname.Length > 30);

        Response.Write("集合中的元素个数，返回int；不延迟+<br/>" + i);


    }

    /// <summary>
    ///Sum - 集合应为数字类型集合，求其和；不延迟
    /// </summary>
    void _Summary_Sum()
    {
        var products = from p in LDb.books
                       select p
                       ;
        //var  i = (from a in LDb.books
        //         select a.bookid).Sum();
       Response.Write("Sum - 集合应为数字类型集合，求其和；不延迟<br/>"+products.Sum(p => p.bookid));
    
    }

    /// <summary>
    /// Min - 返回集合的最小值；不延迟
    /// Max返回集合的最大值；不延迟
    /// </summary>
    void _Summary_Min()//Max()
    {
        //int i = (from a in _ary
        //         select a.Length).Min();
        var product = (from a in LDb.books
                       select a.bookid).Max();
        Response.Write("<br/>"+LDb.books.Min(p => p.bookid));
        //Response.Write("<br/>"+LDb.books.Max(p => p.bookid));

    }
    /// <summary>
    /// Average - 集合应为数字类型集合，求其平均值；不延迟
    /// </summary>
    void _Summary_Average()
    {
        var products = (from p in LDb.books
                        select p.bookid
                            ).Average();
        //the valeue  == prodocts : LDb.books.Average(p => p.bookid);
        Response.Write("<br/>" + products);
    }



    /// <summary>
    /// Aggregate - 根据输入的表达式获取一个聚合值；不延迟
    /// </summary>
    void _Summary_Aggregate()//不支持
    {
        // 以下算法的Aggregate相当于Sum

        var  d = (from a in LDb.books
                    select a.bookid).Aggregate((x, y) => x + y);

        var products = (from p in LDb.books select p.bookid).Aggregate((x, y) => x + y);

        Response.Write(d);
    
    }

    /// <summary>
    /// Cast - 将集合转换为强类型集合；延迟
    /// </summary>
    void _Summary_Cast()
    {
        ///crteat new array
        ArrayList al = new ArrayList();
        al.Add("asp.net");
        al.Add("csharp");
        al.Add("xhtml");

        var list = al.Cast<string>();//转换为强类型 后面一定要加()

        foreach (string s in list)
        {
            Response.Write( s + "<br />");
        }
    }

    /// <summary>
    /// DefaultIfEmpty - 查询结果为空则返回默认值；延迟
    /// </summary>
    void _Summary_DefaultIfEmpty()
    {
        var products = (from p in LDb.books
                       where p.bookname.Length > 30
                       select new
                       {
                           p = p.bookname
                       }).DefaultIfEmpty();
        //DefaultIfEmpty("dfsd")设定默认值为 dfsd

        Response.Write("查询结果为空则返回默认值；延迟<br/>");
        foreach (var s in products)
        {
            Response.Write(s.p + "<br />");
        }
    }

    /// <summary>
    /// SequenceEqual - 判断两个集合是否相同；不延迟
    /// </summary>
    void _Summary_SequenceEqual()//不支持
    {
        var product = (from p in LDb.books select p)
            .SequenceEqual(LDb.books);//看看是不是两个东东相等
        Response.Write(product);
    }

    /// <summary>
    /// OfType - 过滤集合中的指定类型；延迟
    /// </summary>
    void _Summary_OfType()
    {
        object[] objects = { 1, "a", 2, "b", 3, "c" };


        var list = objects.OfType<string>();//所是string类型的全部读出来

        foreach (var s in list)
        {
            Response.Write(s + "<br />");
        }

    }

    /// <summary>
    /// 将集合转换为数组；不延迟
    /// </summary>
    void _Summary_ToArray()
    {
        var prodects = LDb.books.Where(p => p.bookname.Length > 10).ToArray();

        foreach (var s in prodects)
        {
            Response.Write(s.bookid + "<br/>");
        }
    }

    /// <summary>
    /// ToList - 将集合转换为List<T>集合；不延迟
    /// </summary>
    void _Summary_ToLsit()
    {
        var prodects = LDb.books.Where(p => p.bookname.Length > 10).ToList();

        foreach (var s in prodects)
        {
            Response.Write(s.bookname + "<br/>");
        }
    }

    /// <summary>
    /// ToDictionary - 将集合转换为<K, V>集合；不延迟
    /// </summary>
    void _Summary_ToDictionary()
    {
        var pp = (from p in LDb.books
                        where
                        p.bookname.ToString() != ""
                  select new { id = p.bookname ,o=p.bookid}).ToDictionary(s=>s.o);
                        

        foreach (var s in pp)
        {
            Response.Write(s.Key +"+dd+s.value="+s.Value +"<br/>");
        }

    }
    #endregion

}
